Optimisasi Kueri ORM Django: select_related vs. prefetch_related

Seiring berkembangnya aplikasi Django Anda, kueri database yang efisien menjadi sangat penting untuk menjaga performa yang optimal. Django ORM menyediakan alat yang canggih untuk meminimalkan panggilan ke database dan meningkatkan kecepatan kueri. Dua teknik utama untuk mencapai ini adalah select_related dan prefetch_related. Panduan komprehensif ini akan menjelaskan konsep-konsep ini, menunjukkan penggunaannya dengan contoh-contoh praktis, dan membantu Anda memilih alat yang tepat untuk kebutuhan spesifik Anda.

Memahami Masalah N+1

Sebelum membahas select_related dan prefetch_related, penting untuk memahami masalah yang mereka selesaikan: masalah kueri N+1. Ini terjadi ketika aplikasi Anda menjalankan satu kueri awal untuk mengambil satu set objek, dan kemudian membuat kueri tambahan (kueri N, di mana N adalah jumlah objek) untuk mengambil data terkait untuk setiap objek.

Perhatikan contoh sederhana dengan model yang merepresentasikan penulis dan buku:

            class Author(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

            

              
                Copy
              
            
          

Sekarang, bayangkan Anda ingin menampilkan daftar buku beserta penulisnya. Pendekatan naif mungkin terlihat seperti ini:

            books = Book.objects.all()
for book in books:
    print(f"{book.title} by {book.author.name}")

            

              
                Copy
              
            
          

Kode ini akan menghasilkan satu kueri untuk mengambil semua buku dan kemudian satu kueri untuk setiap buku untuk mengambil penulisnya. Jika Anda memiliki 100 buku, Anda akan menjalankan 101 kueri, yang menyebabkan overhead performa yang signifikan. Inilah yang disebut masalah N+1.

Memperkenalkan select_related

select_related digunakan untuk mengoptimalkan kueri yang melibatkan relasi one-to-one dan foreign key. Cara kerjanya adalah dengan menggabungkan (JOIN) tabel-tabel terkait dalam kueri awal, sehingga secara efektif mengambil data terkait dalam satu kali panggilan ke database.

Mari kita kembali ke contoh penulis dan buku kita. Untuk menghilangkan masalah N+1, kita dapat menggunakan select_related seperti ini:

            books = Book.objects.all().select_related('author')
for book in books:
    print(f"{book.title} by {book.author.name}")

            

              
                Copy
              
            
          

Sekarang, Django akan menjalankan satu kueri tunggal yang lebih kompleks yang menggabungkan tabel Book dan Author. Ketika Anda mengakses book.author.name di dalam loop, datanya sudah tersedia, dan tidak ada kueri database tambahan yang dilakukan.

Menggunakan select_related dengan Relasi Ganda

select_related dapat melintasi beberapa relasi. Misalnya, jika Anda memiliki model dengan foreign key ke model lain, yang pada gilirannya memiliki foreign key ke model lainnya lagi, Anda dapat menggunakan select_related untuk mengambil semua data terkait dalam satu kali proses.

            class Country(models.Model):
    name = models.CharField(max_length=255)

class AuthorProfile(models.Model):
    author = models.OneToOneField(Author, on_delete=models.CASCADE)
    country = models.ForeignKey(Country, on_delete=models.CASCADE)

# Add country to Author
Author.profile = models.OneToOneField(AuthorProfile, on_delete=models.CASCADE, null=True, blank=True)

authors = Author.objects.all().select_related('profile__country')
for author in authors:
    print(f"{author.name} is from {author.profile.country.name if author.profile else 'Unknown'}")

            

              
                Copy
              
            
          

Dalam kasus ini, select_related('profile__country') mengambil AuthorProfile dan Country terkait dalam satu kueri. Perhatikan notasi garis bawah ganda (__), yang memungkinkan Anda untuk melintasi pohon relasi.

Keterbatasan select_related

select_related paling efektif dengan relasi one-to-one dan foreign key. Ini tidak cocok untuk relasi many-to-many atau relasi foreign key terbalik, karena dapat menyebabkan kueri yang besar dan tidak efisien saat berhadapan dengan dataset terkait yang besar. Untuk skenario ini, prefetch_related adalah pilihan yang lebih baik.

Memperkenalkan prefetch_related

prefetch_related dirancang untuk mengoptimalkan kueri yang melibatkan relasi many-to-many dan foreign key terbalik. Alih-alih menggunakan join, prefetch_related melakukan kueri terpisah untuk setiap relasi dan kemudian menggunakan Python untuk "menggabungkan" hasilnya. Meskipun ini melibatkan beberapa kueri, ini bisa lebih efisien daripada menggunakan join saat berhadapan dengan dataset terkait yang besar.

Perhatikan skenario di mana setiap buku dapat memiliki beberapa genre:

            class Genre(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    genres = models.ManyToManyField(Genre)

            

              
                Copy
              
            
          

Untuk mengambil daftar buku beserta genrenya, menggunakan select_related tidak akan sesuai. Sebaliknya, kita menggunakan prefetch_related:

            books = Book.objects.all().prefetch_related('genres')
for book in books:
    genre_names = [genre.name for genre in book.genres.all()]
    print(f"{book.title} ({', '.join(genre_names)}) by {book.author.name}")

            

              
                Copy
              
            
          

Dalam kasus ini, Django akan menjalankan dua kueri: satu untuk mengambil semua buku dan satu lagi untuk mengambil semua genre yang terkait dengan buku-buku tersebut. Kemudian, ia menggunakan Python untuk secara efisien mengasosiasikan genre dengan buku masing-masing.

prefetch_related dengan Foreign Key Terbalik

prefetch_related juga berguna untuk mengoptimalkan relasi foreign key terbalik. Perhatikan contoh berikut:

            class Author(models.Model):
    name = models.CharField(max_length=255)
    country = models.CharField(max_length=255, blank=True, null=True) # Added for clarity

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)

            

              
                Copy
              
            
          

Untuk mengambil daftar penulis dan buku-buku mereka:

            authors = Author.objects.all().prefetch_related('books')
for author in authors:
    book_titles = [book.title for book in author.books.all()]
    print(f"{author.name} has written: {', '.join(book_titles)}")

            

              
                Copy
              
            
          

Di sini, prefetch_related('books') mengambil semua buku yang terkait dengan setiap penulis dalam kueri terpisah, menghindari masalah N+1 saat mengakses author.books.all().

Menggunakan prefetch_related dengan queryset

Anda dapat lebih lanjut menyesuaikan perilaku prefetch_related dengan menyediakan queryset kustom untuk mengambil objek terkait. Ini sangat berguna ketika Anda perlu memfilter atau mengurutkan data terkait.

            from django.db.models import Prefetch

authors = Author.objects.prefetch_related(Prefetch('books', queryset=Book.objects.filter(title__icontains='django')))

for author in authors:
    django_books = author.books.all()
    print(f"{author.name} has written {len(django_books)} books about Django.")

            

              
                Copy
              
            
          

Dalam contoh ini, objek Prefetch memungkinkan kita untuk menentukan queryset kustom yang hanya mengambil buku yang judulnya mengandung "django".

Merangkai prefetch_related

Mirip dengan select_related, Anda dapat merangkai panggilan prefetch_related untuk mengoptimalkan beberapa relasi:

            authors = Author.objects.all().prefetch_related('books__genres')

for author in authors:
  for book in author.books.all():
    genres = book.genres.all()
    print(f"{author.name} wrote {book.title} which is of genre(s) {[genre.name for genre in genres]}")

            

              
                Copy
              
            
          

Contoh ini melakukan prefetch pada buku-buku yang terkait dengan penulis, dan kemudian genre yang terkait dengan buku-buku tersebut. Menggunakan prefetch_related berantai memungkinkan Anda untuk mengoptimalkan relasi yang bersarang dalam.

select_related vs. prefetch_related: Memilih Alat yang Tepat

Jadi, kapan Anda harus menggunakan select_related dan kapan Anda harus menggunakan prefetch_related? Berikut adalah pedoman sederhana:

• select_related: Gunakan untuk relasi one-to-one dan foreign key di mana Anda perlu sering mengakses data terkait. Ini melakukan join di database, jadi umumnya lebih cepat untuk mengambil data terkait dalam jumlah kecil.
• prefetch_related: Gunakan untuk relasi many-to-many dan foreign key terbalik, atau saat berhadapan dengan dataset terkait yang besar. Ini melakukan kueri terpisah dan menggunakan Python untuk menggabungkan hasilnya, yang bisa lebih efisien daripada join yang besar. Gunakan juga ketika Anda perlu menggunakan pemfilteran queryset kustom pada objek terkait.

Singkatnya:

• Tipe Relasi: select_related (ForeignKey, OneToOne), prefetch_related (ManyToManyField, foreign key terbalik)
• Tipe Kueri: select_related (JOIN), prefetch_related (Kueri Terpisah + Gabungan Python)
• Ukuran Data: select_related (Data terkait kecil), prefetch_related (Data terkait besar)

Contoh Praktis dan Praktik Terbaik

Berikut adalah beberapa contoh praktis dan praktik terbaik untuk menggunakan select_related dan prefetch_related dalam skenario dunia nyata:

• E-commerce: Saat menampilkan detail produk, gunakan select_related untuk mengambil kategori dan produsen produk. Gunakan prefetch_related untuk mengambil gambar produk atau produk terkait.
• Media Sosial: Saat menampilkan profil pengguna, gunakan prefetch_related untuk mengambil postingan dan pengikut pengguna. Gunakan select_related untuk mengambil informasi profil pengguna.
• Sistem Manajemen Konten (CMS): Saat menampilkan artikel, gunakan select_related untuk mengambil penulis dan kategori. Gunakan prefetch_related untuk mengambil tag dan komentar artikel.

Praktik Terbaik Umum:

• Profil Kueri Anda: Gunakan Django debug toolbar atau alat profiling lainnya untuk mengidentifikasi kueri yang lambat dan potensi masalah N+1.
• Mulai dari yang Sederhana: Mulailah dengan implementasi naif dan kemudian optimalkan berdasarkan hasil profiling.
• Uji Secara Menyeluruh: Pastikan bahwa optimisasi Anda tidak menimbulkan bug baru atau regresi performa.
• Pertimbangkan Caching: Untuk data yang sering diakses, pertimbangkan untuk menggunakan mekanisme caching (misalnya, kerangka kerja cache Django atau Redis) untuk lebih meningkatkan performa.
• Gunakan indeks di database: Ini adalah suatu keharusan untuk performa kueri yang optimal, terutama di lingkungan produksi.

Teknik Optimisasi Lanjutan

Selain select_related dan prefetch_related, ada teknik lanjutan lain yang dapat Anda gunakan untuk mengoptimalkan kueri Django ORM Anda:

• only() dan defer(): Metode ini memungkinkan Anda untuk menentukan field mana yang akan diambil dari database. Gunakan only() untuk mengambil hanya field yang diperlukan, dan defer() untuk mengecualikan field yang tidak segera dibutuhkan.
• values() dan values_list(): Metode ini memungkinkan Anda untuk mengambil data sebagai dictionary atau tuple, bukan instance model Django. Ini bisa lebih efisien ketika Anda hanya membutuhkan sebagian dari field model.
• Kueri SQL Mentah: Dalam beberapa kasus, Django ORM mungkin bukan cara yang paling efisien untuk mengambil data. Anda dapat menggunakan kueri SQL mentah untuk kueri yang kompleks atau yang sangat dioptimalkan.
• Optimisasi Spesifik Database: Database yang berbeda (misalnya, PostgreSQL, MySQL) memiliki teknik optimisasi yang berbeda. Teliti dan manfaatkan fitur spesifik database untuk lebih meningkatkan performa.

Pertimbangan Internasionalisasi

Saat mengembangkan aplikasi Django untuk audiens global, penting untuk mempertimbangkan internasionalisasi (i18n) dan lokalisasi (l10n). Hal ini dapat memengaruhi kueri database Anda dalam beberapa cara:

• Data Spesifik Bahasa: Anda mungkin perlu menyimpan terjemahan konten di database Anda. Gunakan kerangka kerja i18n Django untuk mengelola terjemahan dan memastikan bahwa kueri Anda mengambil versi data dalam bahasa yang benar.
• Set Karakter dan Collation: Pilih set karakter dan collation yang sesuai untuk database Anda untuk mendukung berbagai macam bahasa dan karakter.
• Zona Waktu: Saat berurusan dengan tanggal dan waktu, perhatikan zona waktu. Simpan tanggal dan waktu dalam UTC dan konversikan ke zona waktu lokal pengguna saat menampilkannya.
• Pemformatan Mata Uang: Saat menampilkan harga, gunakan simbol dan pemformatan mata uang yang sesuai berdasarkan lokal pengguna.

Kesimpulan

Mengoptimalkan kueri Django ORM sangat penting untuk membangun aplikasi web yang skalabel dan berkinerja tinggi. Dengan memahami dan menggunakan select_related dan prefetch_related secara efektif, Anda dapat secara signifikan mengurangi jumlah kueri database dan meningkatkan responsivitas aplikasi Anda secara keseluruhan. Ingatlah untuk memprofil kueri Anda, menguji optimisasi Anda secara menyeluruh, dan mempertimbangkan teknik lanjutan lainnya untuk lebih meningkatkan performa. Dengan mengikuti praktik terbaik ini, Anda dapat memastikan bahwa aplikasi Django Anda memberikan pengalaman pengguna yang lancar dan efisien, terlepas dari ukuran atau kompleksitasnya. Pertimbangkan juga bahwa desain database yang baik dan indeks yang dikonfigurasi dengan benar adalah suatu keharusan untuk performa yang optimal.